home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / inopts.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  14.2 KB  |  455 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. #ifdef UNIX
  24. #define NOTLIB
  25. #include <defs.h>
  26. #include <term.h>
  27. #endif
  28.  
  29. /* undefine any macros for functions defined in this module */
  30. #undef    cbreak
  31. #undef    nocbreak
  32. #undef    echo
  33. #undef    noecho
  34. #undef    halfdelay
  35. #undef    intrflush
  36. #undef    keypad
  37. #undef    meta
  38. #undef    nodelay
  39. #undef    notimeout
  40. #undef    raw
  41. #undef    noraw
  42. #undef    noqiflush
  43. #undef    qiflush
  44. #undef    timeout
  45. #undef    wtimeout
  46. #undef    typeahead
  47.  
  48. /* undefine any macros for functions called by this module if in debug mode */
  49. #ifdef PDCDEBUG
  50. #  undef    move
  51. #  undef    wmove
  52. #endif
  53.  
  54. #ifdef PDCDEBUG
  55. char *rcsid_inopts  = "$Id$";
  56. #endif
  57.  
  58. /*man-start*********************************************************************
  59.  
  60.   Name:                                                        inopts
  61.  
  62.   Synopsis:
  63.       int cbreak(void);
  64.       int nocbreak(void);
  65.       int echo(void);
  66.       int noecho(void);
  67.   ***    int halfdelay(int tenths);
  68.       int intrflush(WINDOW *win, bool bf);
  69.       int keypad(WINDOW *win, bool bf);
  70.       int meta(WINDOW *win, bool bf);
  71.       int nodelay(WINDOW *win, bool bf);
  72.       int notimeout(WINDOW *win, bool bf);
  73.       int raw(void);
  74.       int noraw(void);
  75.   ***    void noqiflush(void);
  76.   ***    void qiflush(void);
  77.   ***    int timeout(int delay);
  78.   ***    int wtimeout(WINDOW *win, int delay);
  79.       int typeahead(int fildes);
  80.  
  81.   X/Open Description:
  82.      cbreak() and nocbreak() puts the terminal into and out of cbreak
  83.      mode. In cbreak mode, characters typed by the user are immediately
  84.      available to the program and erase/kill character processing is
  85.      not performed.  When out of cbreak mode, the terminal driver
  86.      will buffer characters typed until a newline or carriage return
  87.      is typed.  Interrupt and flow control characters are unaffected
  88.      by this mode.  Initially the terminal may or may not need be
  89.      in cbreak mode.
  90.  
  91.      echo() and noecho() control whether characters typed by the user
  92.      are echoed by the input routine.  Initially, input characters
  93.      are echoed.  Subsequent calls to echo() and noecho() do not
  94.      flush type-ahead.
  95.  
  96.      If the intrflush() option is enabled (bf is TRUE), and an interrupt
  97.      is pressed on the keyboard (INTR, BREAK, or QUIT) all output in
  98.      the terminal driver queue will be flushed, giving the effect
  99.      of faster response to the interrupt but causing curses to have
  100.      the wrong idea of what is on the screen.  Disabling the option
  101.      prevents the flush.  The default for the option is inherited
  102.      from the terminal driver settings.  The window argument is
  103.      ignored.
  104.  
  105.      The keypad() function changes the keypad option of the user's terminal.
  106.      If enabled (bf is TRUE), the user can press a function key (such
  107.      as the left arrow key) and getch() will return a single value
  108.      that represents the KEY_LEFT function key.  (See Section 11.3.3,
  109.      Input Values.)  If disabled, curses will not treat function keys
  110.      as special keys and the program has to interpret the escape
  111.      sequences itself.  If the keypad is enabled, the terminal keypad
  112.      is turned on before input begins.
  113.  
  114.      The meta() function forces the user's terminal to return 7 or 8
  115.      significant bits on input.  To force 8 bits to be returned,
  116.      invoke meta() with bf as TRUE.  To force 7 bits to be returned,
  117.      invoke meta() with bf as FALSE.
  118.      The window argument is always ignored, but it must still be a
  119.      valid window to avoid compiler errors.
  120.  
  121.      The nodelay() function controls whether wgetch() is a non-blocking
  122.      call. If the option is enabled, and no input is ready, wgetch()
  123.      will return ERR. If disabled, wgetch() will hang until input
  124.      is ready.
  125.  
  126.      While interpreting an input escape sequence, wgetch sets a timer while
  127.      waiting for the next character.  If notimeout(win,TRUE) is called, then
  128.      wgetch does not set a timer.  The purpose of the timeout is to
  129.      differentiate between sequences received from a function key and those
  130.      typed by a user.
  131.  
  132.      With raw() and noraw(), the terminal in placed into or out of raw 
  133.      mode.  Raw mode is similar to cbreak mode, in that characters typed 
  134.      are immediately passed through to the user program.  The differences
  135.      are that in raw mode, the INTR, QUIT, SUSP, and STOP characters are 
  136.      passed through without being interpreted, and without generating a
  137.      signal.  The behaviour of the BREAK key depends on other
  138.      parameters of the terminal drive that are not set by curses.
  139.  
  140.      The curses package does the "line-breakout optimisation" by
  141.      looking for type-ahead periodically while updating the screen.
  142.      If input is found, the current update will be postponed until
  143.      refresh() or doupdate() are called again.  This allows faster
  144.      response to commands typed in advance.  Normally, the input FILE
  145.      pointer passed to newterm(), or stdin in the case when initscr()
  146.      was called, will be used to do this type-ahead checking.  The
  147.      typeahead() routine specified that the file descriptor fd is to
  148.      be used to check for type-ahead instead.  If fd is -1, then no
  149.      type-ahead checking will be done.
  150.  
  151.   PDCurses Description:
  152.      The meta() function is provided for portability.  By default, 8 bits
  153.      are returned.
  154.  
  155.      notimeout() is a no-op in PDCurses.
  156.  
  157.   X/Open Return Value:
  158.      All functions return OK on success and ERR on error.
  159.  
  160.   X/Open Errors:
  161.      No errors are defined for this function.
  162.  
  163.   Portability                             X/Open    BSD    SYS V
  164.                                           Dec '88
  165.       cbreak                                Y        Y       Y
  166.       nocbreak                              Y        Y       Y
  167.       echo                                  Y        Y       Y
  168.       noecho                                Y        Y       Y
  169.       halfdelay                             Y        Y       Y
  170.       intrflush                             Y        Y       Y
  171.       keypad                                Y        Y       Y
  172.       meta                                  Y        Y       Y
  173.       nodelay                               Y        Y       Y
  174.       notimeout                             Y        Y       Y
  175.       raw                                   Y        Y       Y
  176.       noraw                                 Y        Y       Y
  177.       noqiflush                             Y        Y       Y
  178.       qiflush                               Y        Y       Y
  179.       timeout                               Y        Y       Y
  180.       wtimeout                              Y        Y       Y
  181.       typeahead                             Y        Y       Y
  182.  
  183. **man-end**********************************************************************/
  184.  
  185. /***********************************************************************/
  186. int    cbreak(void)
  187. /***********************************************************************/
  188. {
  189. #ifdef PDCDEBUG
  190.     if (trace_on) PDC_debug("cbreak() - called\n");
  191. #endif
  192.  
  193. #ifdef UNIX
  194. #ifdef USE_TERMIO
  195.     _CUR_TERM.prog_mode.c_lflag &= ~(ICANON);
  196.     _CUR_TERM.prog_mode.c_iflag &= ~(ICRNL);
  197. /*    _CUR_TERM.prog_mode.c_lflag |= ISIG;*/
  198.     _CUR_TERM.prog_mode.c_cc[VMIN] = 1;
  199.     _CUR_TERM.prog_mode.c_cc[VTIME] = 0;
  200.     ioctl(_CUR_TERM.fd, TCSETAW, &_CUR_TERM.prog_mode);
  201. #else
  202.     _CUR_TERM.prog_mode.sg_flags |= CBREAK;
  203.     ioctl(_CUR_TERM.fd, TIOCSETP, &_CUR_TERM.prog_mode);
  204. #endif
  205.  
  206. #endif
  207.  
  208.     _cursvar.cbreak = TRUE;
  209.     return( OK );
  210. }
  211. /***********************************************************************/
  212. int    nocbreak(void)
  213. /***********************************************************************/
  214. {
  215. #ifdef PDCDEBUG
  216.     if (trace_on) PDC_debug("nocbreak() - called\n");
  217. #endif
  218.  
  219. #ifdef UNIX
  220. #ifdef USE_TERMIO
  221.     _CUR_TERM.prog_mode.c_lflag |= ICANON;
  222.     ioctl(_CUR_TERM.fd, TCSETAW, &_CUR_TERM.prog_mode);
  223. #else 
  224.     _CUR_TERM->prog_mode.sg_flags &= ~CBREAK;
  225.     ioctl(_CUR_TERM.fd, TIOCSETP,&_CUR_TERM.prog_mode);
  226. #endif
  227. #endif
  228.  
  229.     _cursvar.cbreak = FALSE;
  230.     return( OK );
  231. }
  232. /***********************************************************************/
  233. int    echo(void)
  234. /***********************************************************************/
  235. {
  236. #ifdef PDCDEBUG
  237.     if (trace_on) PDC_debug("echo() - called\n");
  238. #endif
  239.  
  240. #ifdef UNIX
  241. #ifdef USE_TERMIO
  242.     _CUR_TERM.prog_mode.c_lflag |= ECHOCTL|ECHOKE;
  243.     ioctl(_CUR_TERM.fd, TCSETAW, &_CUR_TERM.prog_mode);
  244. #else
  245.     _CUR_TERM.prog_mode.sg_flags |= ECHO;
  246.     ioctl(_CUR_TERM.fd, TIOCSETP, &_CUR_TERM.prog_mode);
  247. #endif
  248. #endif
  249.  
  250.     _cursvar.echo = TRUE;
  251.     return( OK );
  252. }
  253. /***********************************************************************/
  254. int    noecho(void)
  255. /***********************************************************************/
  256. {
  257. #ifdef PDCDEBUG
  258.     if (trace_on) PDC_debug("noecho() - called\n");
  259. #endif
  260.  
  261. #ifdef UNIX
  262. #ifdef USE_TERMIO
  263.     _CUR_TERM.prog_mode.c_lflag &= ~(ECHO|ECHOPRT);
  264.     ioctl(_CUR_TERM.fd, TCSETAW, &_CUR_TERM.prog_mode);
  265. #else
  266.     _CUR_TERM.prog_mode.sg_flags &= ~ECHO;
  267.     ioctl(_CUR_TERM.fd, TIOCSETP, &_CUR_TERM.prog_mode);
  268. #endif
  269. #endif
  270.  
  271.     _cursvar.echo = FALSE;
  272.     return( OK );
  273. }
  274. /***********************************************************************/
  275. int    intrflush( WINDOW *win, bool bf )
  276. /***********************************************************************/
  277. {
  278. #ifdef    TC
  279. #  pragma argsused
  280. #endif
  281.     int    y;
  282.     int    maxy;
  283.  
  284. #ifdef PDCDEBUG
  285.     if (trace_on) PDC_debug("intrflush() - called\n");
  286. #endif
  287.  
  288.     if (win == (WINDOW *)NULL)
  289.         return( ERR );
  290.  
  291.     maxy = win->_maxy - 1;
  292.  
  293.     for (y = 0; y <= maxy; y++)
  294.     {
  295.         win->_firstch[y] = _NO_CHANGE;
  296.     }
  297.     return( OK );
  298. }
  299. /***********************************************************************/
  300. int    keypad( WINDOW *win, bool bf )
  301. /***********************************************************************/
  302. {
  303. #ifdef PDCDEBUG
  304.     if (trace_on) PDC_debug("keypad() - called\n");
  305. #endif
  306.  
  307.     win->_use_keypad = bf;
  308.     return( OK );
  309. }
  310. /***********************************************************************/
  311. int    meta( WINDOW *win, bool bf )
  312. /***********************************************************************/
  313. {
  314. #ifdef PDCDEBUG
  315.     if (trace_on) PDC_debug("meta() - called\n");
  316. #endif
  317.  
  318. #ifdef UNIX
  319. /* INCOMPLETE */
  320. #endif
  321.  
  322. #ifdef    TC
  323. # pragma argsused;
  324. #endif
  325.     _cursvar.raw_inp = bf;
  326.     return( OK );
  327. }
  328. /***********************************************************************/
  329. int    nodelay( WINDOW *win, bool flag )
  330. /***********************************************************************/
  331. {
  332. #ifdef PDCDEBUG
  333.     if (trace_on) PDC_debug("nodelay() - called\n");
  334. #endif
  335.  
  336.     win->_nodelay = flag;
  337.     return( OK );
  338. }
  339. /***********************************************************************/
  340. int    notimeout( WINDOW *win, bool flag )
  341. /***********************************************************************/
  342. {
  343. #ifdef PDCDEBUG
  344.     if (trace_on) PDC_debug("notimeout() - called\n");
  345. #endif
  346.  
  347.     return( OK );
  348. }
  349. /***********************************************************************/
  350. int    raw(void)
  351. /***********************************************************************/
  352. {
  353. #ifdef OS2
  354. # ifndef EMXVIDEO
  355.     KBDINFO KbdInfo;
  356. # endif
  357. #endif
  358.  
  359. #ifdef PDCDEBUG
  360.     if (trace_on) PDC_debug("raw() - called\n");
  361. #endif
  362.  
  363. #ifdef OS2
  364. # ifndef EMXVIDEO
  365.     KbdGetStatus(&KbdInfo,0);
  366.     KbdInfo.fsMask |= KEYBOARD_BINARY_MODE;
  367.     KbdInfo.fsMask &= ~KEYBOARD_ASCII_MODE;
  368.     KbdSetStatus(&KbdInfo,0);
  369. # endif
  370. #endif
  371.  
  372. #if defined( UNIX )    /* || defined( EMXVIDEO )    NOT COMPLETED */
  373. #ifdef USE_TERMIO
  374. #if 0
  375.     _CUR_TERM.prog_mode.c_lflag &= ~(ICANON|ISIG);
  376.     _CUR_TERM.prog_mode.c_iflag &= ~(INPCK|ISTRIP|IXON);
  377.     _CUR_TERM.prog_mode.c_oflag &= ~(OPOST);
  378.     _CUR_TERM.prog_mode.c_cc[VMIN] = 1;
  379.     _CUR_TERM.prog_mode.c_cc[VTIME] = 0;
  380.     ioctl(_CUR_TERM.fd, TCSETAW, &_CUR_TERM.prog_mode);
  381. #endif
  382.     _CUR_TERM.prog_mode.c_lflag &= ~(ICANON|ISIG);
  383.     _CUR_TERM.prog_mode.c_iflag &= ~(IXON);
  384.     _CUR_TERM.prog_mode.c_iflag |= ICRNL;
  385.     ioctl(_CUR_TERM.fd, TCSETAW, &_CUR_TERM.prog_mode);
  386. #else
  387.     _CUR_TERM.prog_mode.sg_flags |= RAW;
  388.     ioctl(_CUR_TERM.fd, TIOCSETP, &_CUR_TERM.prog_mode);
  389. #endif
  390. #endif
  391.  
  392.     _cursvar.raw_inp = TRUE;
  393.     PDC_set_ctrl_break(FALSE);      /* disallow ^BREAK on disk I/O */
  394. /*    flushinp(); */
  395.     return( OK );
  396. }
  397. /***********************************************************************/
  398. int    noraw(void)
  399. /***********************************************************************/
  400. {
  401. #ifdef OS2
  402. # ifndef EMXVIDEO
  403.     KBDINFO KbdInfo;
  404. # endif
  405. #endif
  406.  
  407. #ifdef PDCDEBUG
  408.     if (trace_on) PDC_debug("noraw() - called\n");
  409. #endif
  410.  
  411. #ifdef OS2
  412. # ifndef EMXVIDEO
  413.     KbdGetStatus(&KbdInfo,0);
  414.     KbdInfo.fsMask |= KEYBOARD_ASCII_MODE;
  415.     KbdInfo.fsMask &= ~KEYBOARD_BINARY_MODE;
  416.     KbdSetStatus(&KbdInfo,0);
  417. # endif
  418. #endif
  419.  
  420. #if defined( UNIX ) /* || defined( EMXVIDEO ) NOT COMPLETE */
  421. #ifdef USE_TERMIO
  422. #if 0
  423.     _CUR_TERM.prog_mode.c_lflag |= ISIG|ICANON;
  424.     _CUR_TERM.prog_mode.c_iflag |= IXON|INPCK|ISTRIP;
  425.     _CUR_TERM.prog_mode.c_oflag |= OPOST;
  426.     _CUR_TERM.prog_mode.c_cc[VMIN] = _CUR_TERM.shell_mode.c_cc[VMIN];
  427.     _CUR_TERM.prog_mode.c_cc[VTIME] = _CUR_TERM.shell_mode.c_cc[VTIME];
  428. #endif
  429.     _CUR_TERM.prog_mode.c_lflag |= ICANON;
  430.     ioctl(_CUR_TERM.fd, TCSETAW, &_CUR_TERM.prog_mode);
  431. #else
  432.     _CUR_TERM.prog_mode.sg_flags &= ~RAW;
  433.     ioctl(_CUR_TERM.fd, TIOCSETP, &_CUR_TERM.prog_mode);
  434. #endif
  435. #endif
  436.  
  437.     _cursvar.raw_inp = FALSE;
  438.     PDC_set_ctrl_break(TRUE);
  439.     return( OK );
  440. }
  441. /***********************************************************************/
  442. int    typeahead( int fildes )
  443. /***********************************************************************/
  444. {
  445. #ifdef PDCDEBUG
  446.     if (trace_on) PDC_debug("typeahead() - called\n");
  447. #endif
  448.  
  449.     if (fildes < 0)
  450.         _cursvar.refrbrk = FALSE;
  451.     else
  452.         _cursvar.refrbrk = TRUE;
  453.     return(OK);
  454. }
  455.